-- MySQL Administrator dump 1.4
--
-- ------------------------------------------------------
-- Server version	5.1.30-community


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;


--
-- Create schema slrtool
--

CREATE DATABASE IF NOT EXISTS slrtool;
USE slrtool;

--
-- Definition of table `adaptacioncadenas`
--

DROP TABLE IF EXISTS `adaptacioncadenas`;
CREATE TABLE `adaptacioncadenas` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `cadena` varchar(700) DEFAULT NULL COMMENT 'Adaptacion de la cadena de busqueda',
  `fuente` int(10) unsigned NOT NULL COMMENT 'Fuente para la que se adapta la cadena',
  `fechaBusqueda` datetime DEFAULT NULL COMMENT 'Fecha en la que se realiza la busqueda en la fuente',
  `cadenaPrimaria` int(10) unsigned NOT NULL COMMENT 'Cadena de busqueda original a adaptar',
  PRIMARY KEY (`id`),
  UNIQUE KEY `fuente` (`fuente`,`cadenaPrimaria`),
  KEY `FK_AdaptacionCadenas_1` (`cadenaPrimaria`),
  CONSTRAINT `FK_AdaptacionCadenas_1` FOREIGN KEY (`cadenaPrimaria`) REFERENCES `cadenasbusqueda` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_adaptacioncadenas_2` FOREIGN KEY (`fuente`) REFERENCES `fuente` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=latin1 COMMENT='Adaptacion de las cadenas originales a cada buscador';

--
-- Dumping data for table `adaptacioncadenas`
--

/*!40000 ALTER TABLE `adaptacioncadenas` DISABLE KEYS */;
INSERT INTO `adaptacioncadenas` (`id`,`cadena`,`fuente`,`fechaBusqueda`,`cadenaPrimaria`) VALUES 
 (1,'sdf',16,'2009-08-08 21:18:29',14),
 (2,'',17,NULL,14),
 (3,'',18,NULL,14),
 (4,'',19,NULL,14),
 (5,'',20,NULL,14),
 (6,'',16,NULL,15),
 (7,'',17,NULL,15),
 (8,'',18,NULL,15),
 (9,'',19,NULL,15),
 (10,'',20,NULL,15);
/*!40000 ALTER TABLE `adaptacioncadenas` ENABLE KEYS */;


--
-- Definition of table `cadenasbusqueda`
--

DROP TABLE IF EXISTS `cadenasbusqueda`;
CREATE TABLE `cadenasbusqueda` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identidicador',
  `cadena` varchar(500) NOT NULL COMMENT 'Cadena de busqueda original',
  `idRevision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `cadena` (`cadena`,`idRevision`),
  KEY `FK_CadenasBusqueda_1` (`idRevision`),
  CONSTRAINT `FK_CadenasBusqueda_1` FOREIGN KEY (`idRevision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=latin1 COMMENT='Cadenas de búsqueda originales';

--
-- Dumping data for table `cadenasbusqueda`
--

/*!40000 ALTER TABLE `cadenasbusqueda` DISABLE KEYS */;
INSERT INTO `cadenasbusqueda` (`id`,`cadena`,`idRevision`) VALUES 
 (15,'quality and unified modeling language',1),
 (14,'qualiy and uml',1);
/*!40000 ALTER TABLE `cadenasbusqueda` ENABLE KEYS */;


--
-- Definition of table `calidaddocumento`
--

DROP TABLE IF EXISTS `calidaddocumento`;
CREATE TABLE `calidaddocumento` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `calidad` int(10) unsigned NOT NULL COMMENT 'Criterio de calidad en estudio',
  `documento` int(10) unsigned NOT NULL COMMENT 'Documento en estudio',
  `valor` tinyint(1) NOT NULL DEFAULT '0' COMMENT 'Valor de cumplimiento del documento del criterio',
  `revisado` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  UNIQUE KEY `calidad` (`calidad`,`documento`),
  KEY `FK_calidadDocumento_2` (`documento`),
  CONSTRAINT `FK_calidadDocumento_1` FOREIGN KEY (`calidad`) REFERENCES `criteriocalidad` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_calidadDocumento_2` FOREIGN KEY (`documento`) REFERENCES `documento` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=176 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `calidaddocumento`
--

/*!40000 ALTER TABLE `calidaddocumento` DISABLE KEYS */;
INSERT INTO `calidaddocumento` (`id`,`calidad`,`documento`,`valor`,`revisado`) VALUES 
 (116,14,21,0,0),
 (117,14,22,0,0),
 (118,14,23,0,0),
 (119,14,24,0,0),
 (120,14,25,0,0),
 (121,14,26,0,0),
 (122,14,27,0,0),
 (123,14,28,0,0),
 (124,14,29,0,0),
 (125,14,30,0,0),
 (126,14,31,0,0),
 (127,14,32,0,0),
 (128,14,33,0,0),
 (129,14,34,0,0),
 (130,14,35,0,0),
 (131,14,36,0,0),
 (132,14,37,0,0),
 (133,14,38,0,0),
 (134,14,39,0,0),
 (135,14,40,0,0),
 (136,14,41,0,0),
 (137,14,42,0,0),
 (138,14,43,0,0),
 (139,14,44,0,0),
 (140,14,45,0,0),
 (141,14,46,0,0),
 (142,14,47,0,0),
 (143,14,48,0,0),
 (144,14,49,0,0),
 (145,14,51,0,0),
 (146,14,52,0,0),
 (147,14,53,0,0),
 (148,14,54,0,0),
 (149,14,55,0,0),
 (150,14,56,0,0),
 (151,14,57,0,0),
 (152,14,58,0,0),
 (153,14,59,0,0),
 (154,14,60,0,0),
 (155,14,61,0,0),
 (156,14,62,0,0),
 (157,14,63,0,0),
 (158,14,64,0,0),
 (159,14,65,0,0),
 (160,14,66,0,0),
 (161,14,67,0,0),
 (162,14,68,0,0),
 (163,14,69,0,0),
 (164,14,70,0,0),
 (165,14,71,0,0),
 (166,14,72,0,0),
 (167,14,73,0,0),
 (168,14,74,0,0),
 (169,14,75,0,0),
 (170,14,76,0,0),
 (171,14,77,0,0);
/*!40000 ALTER TABLE `calidaddocumento` ENABLE KEYS */;


--
-- Definition of table `categoria`
--

DROP TABLE IF EXISTS `categoria`;
CREATE TABLE `categoria` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `nombre` varchar(45) NOT NULL COMMENT 'Nombre de la categoria',
  `padre` int(10) unsigned DEFAULT NULL COMMENT 'Categoria padre',
  `revision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece la categoria',
  `pregunta` int(10) unsigned DEFAULT NULL COMMENT 'Pregunta de investigacion con la que se relaciona',
  PRIMARY KEY (`id`),
  UNIQUE KEY `nombre` (`nombre`,`padre`,`revision`),
  KEY `FK_categoria_2` (`revision`),
  KEY `FK_categoria_3` (`pregunta`),
  KEY `FK_categoria_1` (`padre`),
  CONSTRAINT `FK_categoria_1` FOREIGN KEY (`padre`) REFERENCES `categoria` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoria_2` FOREIGN KEY (`revision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoria_3` FOREIGN KEY (`pregunta`) REFERENCES `preguntas` (`id`) ON DELETE SET NULL ON UPDATE SET NULL
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `categoria`
--

/*!40000 ALTER TABLE `categoria` DISABLE KEYS */;
INSERT INTO `categoria` (`id`,`nombre`,`padre`,`revision`,`pregunta`) VALUES 
 (1,'Type of diagram',NULL,1,1),
 (2,'Type of quality',NULL,1,5),
 (3,'Syntactic',2,1,5),
 (4,'Semantic',2,1,5),
 (5,'Pragmatic',2,1,5);
/*!40000 ALTER TABLE `categoria` ENABLE KEYS */;


--
-- Definition of table `categoriadocumento`
--

DROP TABLE IF EXISTS `categoriadocumento`;
CREATE TABLE `categoriadocumento` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `documento` int(10) unsigned NOT NULL COMMENT 'Documento que se clasifica',
  `categoria` int(10) unsigned NOT NULL COMMENT 'Categoria del documento',
  `subcategoria` int(10) unsigned DEFAULT NULL COMMENT 'Subcategoria del documento',
  `valor` int(10) unsigned NOT NULL COMMENT 'Valor elegido',
  `revision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `documento` (`documento`,`categoria`) USING BTREE,
  KEY `FK_categoriaDocumento_2` (`categoria`),
  KEY `FK_categoriaDocumento_3` (`subcategoria`),
  KEY `FK_categoriaDocumento_4` (`valor`),
  KEY `FK_categoriadocumento_5` (`revision`),
  CONSTRAINT `FK_categoriaDocumento_1` FOREIGN KEY (`documento`) REFERENCES `documento` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoriaDocumento_2` FOREIGN KEY (`categoria`) REFERENCES `categoria` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoriaDocumento_3` FOREIGN KEY (`subcategoria`) REFERENCES `categoria` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoriaDocumento_4` FOREIGN KEY (`valor`) REFERENCES `valor` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_categoriadocumento_5` FOREIGN KEY (`revision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=72 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `categoriadocumento`
--

/*!40000 ALTER TABLE `categoriadocumento` DISABLE KEYS */;
INSERT INTO `categoriadocumento` (`id`,`documento`,`categoria`,`subcategoria`,`valor`,`revision`) VALUES 
 (4,24,1,NULL,2,1),
 (5,24,2,5,25,1),
 (6,67,1,NULL,1,1),
 (7,67,2,4,15,1),
 (8,48,1,NULL,1,1),
 (9,48,2,5,20,1),
 (10,37,2,5,25,1),
 (11,37,1,NULL,27,1),
 (13,69,1,NULL,27,1),
 (14,69,2,4,17,1),
 (15,36,1,NULL,27,1),
 (16,36,2,4,15,1),
 (17,76,1,NULL,27,1),
 (18,76,2,4,15,1),
 (19,64,1,NULL,27,1),
 (20,64,2,4,16,1),
 (21,72,2,4,15,1),
 (22,72,1,NULL,27,1),
 (23,77,1,NULL,27,1),
 (24,77,2,4,15,1),
 (25,66,2,5,25,1),
 (26,66,1,NULL,27,1),
 (27,57,1,NULL,1,1),
 (28,57,2,5,20,1),
 (29,35,2,4,15,1),
 (30,35,1,NULL,1,1),
 (31,25,1,NULL,1,1),
 (32,25,2,5,20,1),
 (33,51,1,NULL,1,1),
 (34,51,2,5,18,1),
 (35,52,1,NULL,13,1),
 (36,52,2,5,18,1),
 (37,70,1,NULL,27,1),
 (38,70,2,4,16,1),
 (39,55,1,NULL,10,1),
 (40,55,2,5,20,1),
 (41,47,1,NULL,1,1),
 (42,47,2,5,20,1),
 (43,65,1,NULL,27,1),
 (44,65,2,3,14,1),
 (45,45,2,4,15,1),
 (46,45,1,NULL,27,1),
 (47,60,1,NULL,9,1),
 (48,60,2,3,14,1),
 (49,59,1,NULL,10,1),
 (50,59,2,4,15,1),
 (51,56,1,NULL,1,1),
 (52,56,2,5,20,1),
 (53,73,1,NULL,1,1),
 (54,73,2,4,15,1),
 (55,34,1,NULL,27,1),
 (56,34,2,5,18,1),
 (57,58,1,NULL,10,1),
 (58,58,2,4,15,1),
 (59,75,1,NULL,9,1),
 (60,75,2,4,15,1),
 (61,74,1,NULL,9,1),
 (62,74,2,4,17,1),
 (63,71,1,NULL,27,1),
 (64,71,2,4,16,1),
 (65,53,1,NULL,1,1),
 (66,53,2,5,20,1),
 (67,33,1,NULL,27,1),
 (68,33,2,5,18,1),
 (69,42,1,NULL,1,1),
 (70,42,2,5,18,1);
/*!40000 ALTER TABLE `categoriadocumento` ENABLE KEYS */;


--
-- Definition of table `criteriocalidad`
--

DROP TABLE IF EXISTS `criteriocalidad`;
CREATE TABLE `criteriocalidad` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `descripcion` varchar(200) NOT NULL COMMENT 'Drescripcion del criterio de calidad',
  `revision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `descripcion` (`descripcion`,`revision`) USING BTREE,
  KEY `FK_CriterioCalidad_1` (`revision`),
  CONSTRAINT `FK_CriterioCalidad_1` FOREIGN KEY (`revision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=15 DEFAULT CHARSET=latin1 COMMENT='Elementos del checklist de comprobacion de calidad';

--
-- Dumping data for table `criteriocalidad`
--

/*!40000 ALTER TABLE `criteriocalidad` DISABLE KEYS */;
INSERT INTO `criteriocalidad` (`id`,`descripcion`,`revision`) VALUES 
 (14,'the document is published',1);
/*!40000 ALTER TABLE `criteriocalidad` ENABLE KEYS */;


--
-- Definition of table `criterioexclusion`
--

DROP TABLE IF EXISTS `criterioexclusion`;
CREATE TABLE `criterioexclusion` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `criterio` varchar(200) NOT NULL COMMENT 'Criterio de exclusion',
  `idRevision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `criterio` (`criterio`,`idRevision`),
  KEY `FK_CriterioExclusion_1` (`idRevision`),
  CONSTRAINT `FK_CriterioExclusion_1` FOREIGN KEY (`idRevision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `criterioexclusion`
--

/*!40000 ALTER TABLE `criterioexclusion` DISABLE KEYS */;
INSERT INTO `criterioexclusion` (`id`,`criterio`,`idRevision`) VALUES 
 (5,'docs related with OCL',1),
 (4,'in a language different of English or Spanish',1);
/*!40000 ALTER TABLE `criterioexclusion` ENABLE KEYS */;


--
-- Definition of table `criterioinclusion`
--

DROP TABLE IF EXISTS `criterioinclusion`;
CREATE TABLE `criterioinclusion` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `criterio` varchar(200) NOT NULL COMMENT 'Criterio de inclusion',
  `idRevision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `criterio` (`criterio`,`idRevision`),
  KEY `FK_CriterioInclusion_1` (`idRevision`),
  CONSTRAINT `FK_CriterioInclusion_1` FOREIGN KEY (`idRevision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `criterioinclusion`
--

/*!40000 ALTER TABLE `criterioinclusion` DISABLE KEYS */;
INSERT INTO `criterioinclusion` (`id`,`criterio`,`idRevision`) VALUES 
 (10,'of any type of source',1),
 (9,'published between 1997 and 2007',1);
/*!40000 ALTER TABLE `criterioinclusion` ENABLE KEYS */;


--
-- Definition of table `documento`
--

DROP TABLE IF EXISTS `documento`;
CREATE TABLE `documento` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `ruta` varchar(150) NOT NULL COMMENT 'Ruta donde se encuentra el PDF',
  `titulo` varchar(250) NOT NULL COMMENT 'Titulo del documento',
  `autor` varchar(200) NOT NULL COMMENT 'Autores del documento',
  `resumen` varchar(3500) DEFAULT NULL COMMENT 'Resumen o abstract del documento',
  `keywords` varchar(500) DEFAULT NULL COMMENT 'Palabras clave del documento',
  `journal` varchar(150) DEFAULT NULL COMMENT 'Revista en la que se publico (si procede)',
  `year` int(11) DEFAULT NULL COMMENT 'Año de publicacion',
  `volumen` int(11) DEFAULT NULL COMMENT 'Volumen en el que se publico (si procede)',
  `pages` varchar(15) DEFAULT NULL COMMENT 'Paginas del documento',
  `publisher` varchar(50) DEFAULT NULL COMMENT 'Editorial que lo publico (si procede)',
  `chapter` int(10) unsigned DEFAULT NULL COMMENT 'Numero del capitulo del libro (si procede)',
  `booktitle` varchar(150) DEFAULT NULL COMMENT 'Titulo del libro al que pertenece (si procede)',
  `comentarios` varchar(500) DEFAULT NULL COMMENT 'Comentarios introducidos por el usuario',
  `excluidoPrimera` tinyint(1) DEFAULT '0' COMMENT 'Excluido en la primera revision',
  `excluidoSegunda` tinyint(1) DEFAULT '0' COMMENT 'Excluido en la segunda revision',
  `numero` int(11) DEFAULT NULL COMMENT 'Numero en el que se publico (si procede)',
  `fuente` int(10) unsigned DEFAULT NULL COMMENT 'Fuente de la que se obtuvo',
  `lugar` varchar(100) DEFAULT NULL COMMENT 'Lugar de publicacion (si procede)',
  `edicion` int(10) unsigned DEFAULT NULL COMMENT 'Edicion de publicacion (si procede)',
  `conferencia` varchar(150) DEFAULT NULL COMMENT 'Nombre de la conferencia de publicacion (si procede)',
  `tipo` int(10) unsigned NOT NULL COMMENT 'Tipo de documento',
  `workshop` varchar(150) DEFAULT NULL COMMENT 'Nombre del workshop de publicacion (si procede)',
  PRIMARY KEY (`id`),
  UNIQUE KEY `titulo` (`titulo`),
  KEY `FK_documento_1` (`fuente`),
  KEY `FK_documento_2` (`tipo`),
  CONSTRAINT `FK_documento_1` FOREIGN KEY (`fuente`) REFERENCES `fuente` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_documento_2` FOREIGN KEY (`tipo`) REFERENCES `tipodocumento` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=83 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `documento`
--

/*!40000 ALTER TABLE `documento` DISABLE KEYS */;
INSERT INTO `documento` (`id`,`ruta`,`titulo`,`autor`,`resumen`,`keywords`,`journal`,`year`,`volumen`,`pages`,`publisher`,`chapter`,`booktitle`,`comentarios`,`excluidoPrimera`,`excluidoSegunda`,`numero`,`fuente`,`lugar`,`edicion`,`conferencia`,`tipo`,`workshop`) VALUES 
 (21,'C:\\SLRTool\\Quality in UML\\IEEEa01.pdf','Quality of Service Engineering with UML, .NET, and CORBA','Torben Weis ; Andreas Ulbrich; Kurt Geihs ','The concern for non-functional properties of software components and distributed applications has increased significantly in recent years. Non-functional properties are often subsumed under the term Quality of Service (QoS). It refers to quality aspects of a software component or service such as real-time response guarantees, availability and fault-tolerance, the degree of data consistency, the precision of some computation, or the level of security. Consequently, the specification and implementation of QoS mechanisms has become an important concern in the engineering of distributed applications. In this tutorial the attendees will learn how non-functional requirements can be engineered in a systematic way into applications on top of distribution platforms such as CORBA and .NET. The tutorial focuses on two major subjects areas: (1) Specification of QoS properties and (2) implementation of QoS mechanisms in middleware. We present a comprehensive, model-driven approach. It starts with a platform-independent model (PIM) in UML that captures the application QoS requirements. This model is mapped by a tool to a platform-specific model (PSM) tailored for a specific middleware, which is extended with the corresponding QoS mechanisms. Finally, the PSM is translated to code. Participants in this tutorial will get a thorough understanding of general QoS requirements, QoS modeling alternatives and QoS mechanism integration in respect to popular distributed object middleware. Furthermore, we will discuss the pros and cons of CORBA and .NET for QoS engineering. A tool will be demonstrated that eases substantially the modeling stages and the code generation.','',NULL,2003,NULL,'759',NULL,NULL,NULL,'',1,0,NULL,16,NULL,25,'International Conference on Software Engineering',3,NULL),
 (22,'C:\\SLRTool\\Quality in UML\\IEEE41.pdf','Improving the quality of UML models in practice','Christian F. J. Lange ','The importance of UML models in software engineering is increasing. Inherent to the UML is its lack of a formal semantics, its risk for inconsistency and completeness defects and the absence of modeling norms. These properties are sources for poor model quality and defects. To find out to which extent defects occur and what types of defects occur in practice we empirically investigate the state-of-the-practice of quality in UML models using a practitioners survey and a series of industrial case studies. Additionally we analyze the effects of defects in UML models experimentally. Based on this experiment we present an objective classification of UML defects which allows for prioritizing defects and thus allocate resources for defect removal. We aim at building a rule-set, metrics and visualization techniques to improve the quality of UML models during development. We propose a quality model that is specific for UML models. Finally, we propose modeling conventions, similar to coding conventions, to prevent for defects and to assure uniformity of modeling within an organization. We aim at empirically validating our techniques to provide pragmatic technology that can be transferred to industrial practice.','UML; Quality; Completeness; Consistency; Defect Detection',NULL,2006,NULL,'993-996 ',NULL,NULL,NULL,'',0,1,NULL,16,NULL,28,'Proceedings of the international conference on Software engineering',3,NULL),
 (23,'C:\\SLRTool\\Quality in UML\\IEEEa02.pdf','CPP2XMI: Reverse Engineering of UML Class, Sequence, and Activity Diagrams from C++ Source Code','E. Korshunova ; M. Petkovic ; M.G.J. van den Brand ; M.R. Mousavi ','','',NULL,2006,NULL,'297-298',NULL,NULL,NULL,'',1,0,NULL,16,'',13,'Working Conference on Reverse Engineering ',3,NULL),
 (24,'C:\\SLRTool\\Quality in UML\\IEEE48.pdf','Measuring the Complexity of a UML Component Specification','Sajjad Mahmood ; Richard Lai ','Component Based System (CBS) development is about assembling individual components to produce a working system. However, its overall complexity does not only depend on the complexity of individual components. Further, component source code information is usually unavailable and they introduce additional properties such as constraints associated with its use, interactions among components, and customizability. The traditional complexity metrics are not adequate and do not easily apply to CBS as they mainly focus on either Lines of Codes (LOC) or information based on objects, classes and their inheritance properties. Recent CBS research suggests that most faults are found in few components. A complexity measure at specification level can be used for identifying these components; and precautionary actions can be taken to avoid the likely failures and to lower maintenance costs. There is therefore a need to develop a new technique for measuring the complexity of a component specification. This paper describes a complexity measure for a component specification written in Unified Modeling Language (UML).','',NULL,2005,NULL,'150-160 ',NULL,NULL,NULL,'',0,0,NULL,16,NULL,5,'International Conference on Quality Software',3,NULL),
 (25,'C:\\SLRTool\\Quality in UML\\IEEE63.pdf','Towards the UML Evaluation Using Taxonomic Patterns on Meta-Classes','Haohai Ma ; Zhe Ji ; Weizhong Shao ; Lu Zhang ','In order to evaluate the design quality of the UML, understanding meta-classes is a key activity as they are the primary weapons by which the UML specifies the application domains. The paper introduces taxonomic patterns for clustering the UML metaclasses based on the observation of their evolution and fitness. The result sets of the patterns assist in finding the evidence of the concerns about the UML design and quality. It not only helps to find out problematic meta-classes, possible design defects of the UML and the inconsistency between the UML meta-models and the application domains; but also provides valuable information for guiding the development and evaluation of the UML. The work can be the basis of further quality analysis of the UML meta-models.','Software evaluation, Software Quality; Software evaluation; Software Quality; UML; Meta-class',NULL,2005,NULL,'37-44 ',NULL,NULL,NULL,'',0,0,NULL,16,NULL,5,'International Conference on Quality Software',3,NULL),
 (26,'C:\\SLRTool\\Quality in UML\\IEEEa03.pdf','Towards Making Agent UML Practical: A Textual Notation and a Tool','Michael Winikoff ','Design notations play an important role in designing software. Agent UML (AUML), which extends the widelyused UML notation, has proposed a number of notations for modelling agent systems. Arguably the most influential of the AUML notations has been the sequence diagram for defining interaction patterns between agents. However, AUML is not precisely and formally defined, and there is very little in the way of tool support available. In this paper we describe initial steps at resolving these two issues: we precisely define the syntax of (a subset of) AUML by using a textual notation, and we describe a tool that takes a textual AUML protocol and automatically generates the standard graphical rendition.','',NULL,2005,NULL,'401-412 ',NULL,NULL,NULL,'',1,0,NULL,16,NULL,5,'International Conference on Quality Software',3,NULL),
 (27,'C:\\SLRTool\\Quality in UML\\IEEEa04.pdf','Higher-Order Entity Relationship Modelling with UML','Alexei Tretiakov ; Sven Hartmann ','To explore the use of UML for creating valuerepresentable data models, we use the Object Management Group (OMG) Meta Object Facility (MOF) to formally describe the Higher-order Entity Relationship Model (HERM). In addition, we formally define a UML profile for HERM. By demonstrating that MOF and UML can represent the most critical capabilities of HERM, we open way for better integration of HERM models into projects relying on UML for application modelling and for the use of UML tools for HERM modelling.','',NULL,2005,NULL,'205-214 ',NULL,NULL,NULL,'',1,0,NULL,16,NULL,5,'International Conference on Quality Software',3,NULL),
 (28,'C:\\SLRTool\\Quality in UML\\IEEEa05.pdf','Automatic Generation of Markov Chain Usage Models from Real-Time Software UML Models','Jiong Yan ; Ji Wang ; Huo-wang Chen ','The paper concerns automatic generation of usage models from real-time software UML models. Firstly, we define the reasonably constrained real-time software UML artifacts, which include use case diagrams, timed sequence diagrams and the execution probability of each sequence diagram in its associated use case. Secondly, the paper presents a method that derives the software usage model from the constrained UML artifacts. The method elicits the messages associated with the objects under testing and their occurrence probabilities to generate the usage model of each use case. Timing constraints in sequence diagrams are considered during usage model generation. Then the usage models of use cases are integrated into the software usage model by utilizing the execution sequence relations between use cases. The usage models can be used to generate real-time software statistical test cases and facilitate real-time software statistical testing.','',NULL,2004,NULL,'22-31 ',NULL,NULL,NULL,'',1,0,NULL,16,NULL,4,'International Conference on Quality Software',3,NULL),
 (29,'C:\\SLRTool\\Quality in UML\\IEEEa06.pdf','Complexity Measure for Ontology Based on UML','Dazhou Kang ; Baowen Xu  ; Jianjiang Lu ; William C. Chu ','UML is a good tool to represent ontologies. When using UML for Ontology development, one of the principal goals is to assure the quality of ontologies. UML class diagrams provide a static modeling capability that is well suited for representing ontologies, so the structural complexity of UML class diagram is one of the most important measures to evaluate the quality of the ontologies. This paper uses weighted class dependence graphs to represent a given class diagrams, and then presents a structure complexity measure for the UML class diagrams based on entropy distance. It considers complexity of both classes and relationships between the classes, and presents rules for transforming complexity value of classes and different kinds of relations into a weighted class dependence graphs. This method can measure the structure complexity of class diagrams objectively.','Ontology; UML; class diagrams; complexity measure',NULL,2004,NULL,'222-228 ',NULL,NULL,NULL,'',1,0,NULL,16,NULL,10,'IEEE International Workshop on Future Trends of Distributed Computing Systems',3,NULL),
 (30,'C:\\SLRTool\\Quality in UML\\IEEEa07.pdf','Deriving Software Statistical Testing Model from UML Model','Yan Jiong ; Wang Ji ; Chen Huowang ','Software statistical testing is concerned with testing the entire software systems based on their usage models. In the context of UML-based development, it is desired that usage models can be derived from UML analysis artifacts. This paper presents a method that derives the software usage models from reasonably constrained UML artifacts. The method utilizes use case diagrams, sequence diagrams and the execution probability of each sequence diagram in its associated use case. By projecting the messages in sequence diagrams onto the objects under test, the method elicits messages and their occurrence probabilities for generating the usage model of each use case for the objects under test. Then the usage models of use cases are integrated into the system usage model. The integration procedure will utilize the execution sequential relations between use cases.','',NULL,2003,NULL,'343',NULL,NULL,NULL,'',1,0,NULL,16,NULL,3,'International Conference On Quality Software ',3,NULL),
 (31,'C:\\SLRTool\\Quality in UML\\IEEEa08.pdf','Designing UML diagrams for technical documentation: continuing the collaborative approach to publishing class diagram','Neil MacKinnon ; Steve Murphy ','This paper provides an updated discussion of the authors\' ongoing efforts in developing a design framework for UML diagrams in technical documentation. UML diagrams are a key part of program design. They can enhance understanding of complex programming concepts, and assist in problem analysis and solution design. In a previous paper, \"Designing UML diagrams for technical documentation\" [1], the authors presented a collaborative process that applies established design principles to UML diagrams, improving diagram presentation and shrinking publication costs and schedules. This paper expands on that work, showing how the established process can now be applied to several different modeling tools, including IBM Rational® XDE and Microsoft Visio. It also provides a detailed description of how to export modeling files to other file formats. The authors show how their process workflow has evolved over the past year as it has been applied by developers, writers, and graphic designers at IBM\'s Toronto Software Laboratory, and discuss ways in which they will continue to monitor and improve the efficacy of both the process and resulting diagrams. ','Unified Modeling Language; documentation; graphic design; human factors; visualization; UML diagrams; guidelines',NULL,2004,NULL,'327-328',NULL,NULL,NULL,'',1,0,NULL,16,NULL,22,' annual international conference on Design of communication: The engineering of quality documentation',3,NULL),
 (32,'C:\\SLRTool\\Quality in UML\\IEEE01.pdf','4th workshop on graphical documentation: UML style guidelines','Steve Murphy ; Scott Tilley ; Shihong Huang ','The Unified Modeling Language (UML) is the de facto standard for visually representing modern software systems. This workshop will explore UML style guidelines and their effect on the efficacy of UML diagrams in the context of graphical program documentation. This work is part of an ongoing research program focused on assessing system redocumentation techniques. The workshop is a sequel to workshops held at SIGDOC 2001, SIGDOC 2002, and IWPC 2003.','Documentation; program understanding; visualization',NULL,2004,NULL,'327-328 ',NULL,NULL,NULL,'',0,1,NULL,16,'',22,'international conference on Design of communication: The engineering of quality documentation',3,NULL),
 (33,'C:\\SLRTool\\Quality in UML\\IEEE51.pdf','MetricViewEvolution: UML-based Views for Monitoring Model Evolution and Quality','Christian F.J. Lange ; Martijn A.M. Wijns ; Michel R.V. Chaudron ','As the role of models during software development and maintenance is becoming more and more important, techniques are needed to control a model\'s quality during evolution. We present our tool MetricViewEvolution as a step towards managing model quality during development and evolution. Six views are implemented in MetricViewEvolution that aid the user in tasks such as model understanding, identification of quality problems and evolution trends. The views combine structural model information with metrics data from inside the model and external sources. MetricViewEvolution has been applied successfully in industrial case studies.','',NULL,2007,NULL,'327-328 ',NULL,NULL,NULL,'',0,0,NULL,16,NULL,11,'European Conference on Software Maintenance and Reengineering',3,NULL),
 (34,'C:\\SLRTool\\Quality in UML\\IEEE47.pdf','Managing Model Quality in UML-Based Software Development','Christian F.J. Lange ; Michel R.V. Chaudron ','With the advent of UML and MDA, models play an increasingly important role in software development. Hence, the management of the quality of models is of key importance for completing projects succesfully. However, existing approaches towards software quality focus on the implementation and execution of systems. These existing quality models cannot be straightforwardly mapped to the domain of UML models as source code and models differ in several essential ways (level of abstraction, precision, completeness and consistency). In this paper we present a quality model for managing UML-based software development. This model enables identifying the need for actions for quality improvement already in early stages of the life-cycle. Early actions for quality improvement are less resource intensive and, hence, less cost intensive than later actions. We discuss our experiences in applying the quality model to several industrial case studies. Finally we present a tool that visualizes our quality model. This tool helps in relating management level quality data to detailed data about specific quality subcharacteristics.','',NULL,2005,NULL,'7-16 ',NULL,NULL,NULL,'',0,0,NULL,16,NULL,13,NULL,4,'IEEE International Workshop on Software Technology and Engineering Practice '),
 (35,'C:\\SLRTool\\Quality in UML\\IEEE24.pdf','Consistency and Minimality of UML Class Specifications with Multiplicities and Uniqueness Constraints','Ingo Feinerer ; Gernot Salzer ','The Unified Modeling Language (UML) has become a universal tool for the formal object-oriented specification of hard- and software. In particular, UML class diagrams and so-called multiplicities, which restrict the number of links between objects, are essential when using UML for applications like the specification of admissible configurations of components. In this paper we give a formal definition of the semantics of UML class diagrams and multiplicities. We extend results obtained in the context of Entity Relationship diagrams to cover UML specific extensions like the (non-)uniqueness attribute of binary associations. We show that the consistency of such specifications can be checked in polynomial time, and give an algorithm for computing minimal configurations (models). The core of our approach is a translation of UML class diagrams to Diophantine inequations. ','',NULL,2007,NULL,'411-420',NULL,NULL,NULL,'',0,0,NULL,16,NULL,1,'Joint IEEE/IFIP Symposium on Theoretical Aspects of Software Engineerin',3,NULL),
 (36,'C:\\SLRTool\\Quality in UML\\IEEE19.pdf','Assurance of System Consistency During Independent Creation of UML Diagrams','Lukasz Fryz ; Leszek Kotulski ','Graph transformations are a very intuitive formalism used in visualization, modelling of distributed systems or in support its allocation. The formal description the modelling process (both UML diagram and the trace of designer decisions) complicate its structure; we should be able support both parallel activity of local graph transformation systems and their cooperation for the assurance of the systems consistency. In the paper, the concept of conjugated graphs is introduced for this purpose. Next, the implementation of this concept with the help of aedNLC graph grammar is presented.','',NULL,2007,NULL,'51-58 ',NULL,NULL,NULL,'',0,0,NULL,16,NULL,2,'International Conference on Dependability of Computer Systems',3,NULL),
 (37,'C:\\SLRTool\\Quality in UML\\WILEY01.pdf','A complexity measure for UML component-based system specification','Sajjad Mahmood; Richard Lai','A component-based system (CBS) is integration centric with a focus on assembling individual components to build a software system. In CBS, component source code information is usually unavailable. Each component also introduces added properties such as constraints associated with its use, interactions with other components and customizability properties. Recent research suggests that most faults are found in only a few system components. A complexity measure at a specification phase can identify these components. However, traditional complexity metrics are not adequate for a CBS as they focus mainly on either lines of code (LOC) or information based on object and class properties. There is therefore a need to develop a new technique for measuring the complexity of a CBS specification (CBSS). This paper describes a structural complexity measure for a CBSS written in Unified Modelling Language (UML) from a system analyst\'s point of view. A CBSS consists of individual component descriptions characterized by its syntactic, semantic and interaction properties. We identify three factors, interface, constraints and interaction, as primary contributors to the complexity of a CBSS. We also present an application of our technique to a university course registration system. ','component-based system; component-based system specification; UML; complexity; software metrics',NULL,2006,38,'117 - 134',NULL,NULL,NULL,'',0,0,2,18,NULL,NULL,NULL,6,NULL),
 (38,'C:\\SLRTool\\Quality in UML\\WILEY02.pdf','How design notations affect the comprehension of Web applications','Filippo Ricca; Massimiliano Di Penta; Marco Torchiano; Paolo Tonella; Mariano Ceccato','Web application design requires the modeling of multiple, separate concerns, such as the navigational structure, the business logic and the data persistence. To this aim, several methodologies have been conceived. One of them, the Web Application Extension (WAE), extends the UML notation by means of stereotypes and tagged values intended to capture Web-specific concepts (e.g., the navigational structure). Although the WAE methodology is nowadays quite mature and ready for industrial adoption, the question whether it is able to actually facilitate the task of developers and maintainers has still to be empirically investigated. This paper reports and discusses the results from a controlled experiment on the benefits associated with the use of the WAE notation in the execution of comprehension tasks, carried out before maintenance. The WAE notation was compared against the use of pure unified modified language. Results indicate that the use of the WAE notation significantly improves the level of comprehension, although it does not increase the time needed to perform the comprehension task in a significant way. ','empirical studies; program comprehension; Web applications; design notations','Journal of Software Maintenance and Evolution: Research and Practice',2007,19,'339-359',NULL,NULL,NULL,'',0,1,5,18,NULL,NULL,NULL,6,NULL),
 (39,'C:\\SLRTool\\Quality in UML\\WILEY03.pdf','Measuring the complexity of class diagrams in reverse engineering','Frederick T. Sheldon; Hong Chung','Complexity metrics for object-oriented systems are plentiful. Numerous studies have been undertaken to establish valid and meaningful measures of maintainability as they relate to the static structural characteristics of software. In general, these studies have lacked the empirical validation of their meaning and/or have only succeeded in evaluating partial aspects of the system. In this study we have determined, through limited empirical means, a practical and holistic view by analyzing and comparing the structural characteristics of UML class diagrams as those characteristics relate to or impact maintainability. Class diagrams are composed of three kinds of relation, association, generalization, and aggregation, which make their overall structure difficult to understand. We propose combining these three relations in such a way that enables a comprehensive measure of complexity. Theoretically, this measure is applicable among different class diagrams (including different domains, platforms or systems) to the extent that the measure is widely comparative and context free. Further, this property does not preclude comparison within a specific class diagram (or family) and is therefore very useful in evaluating a given class diagram\'s strengths and weaknesses. We are reporting empirical results that provide a small measure of validity to enable an objective appraisal of both complexity and maintainability without equating the two. Therefore, to evaluate our structural complexity metric, we determined the level of understandability of the system by measuring the time needed to reverse engineer source code into class diagrams including the number of errors produced while creating the diagram. The number of errors produced offers one indicator of maintainability. The results, as compared with other complexity metrics, indicate that our metric shows promise especially if proven to be scalable.','software quality; perfective/corrective maintenance; coupling/cohesion; object-oriented complexity metrics; class inheritance and diagrams','Journal of Software Maintenance and Evolution: Research and Practice',2006,18,'333-350',NULL,NULL,NULL,'',1,0,5,18,NULL,NULL,NULL,6,NULL),
 (40,'C:\\SLRTool\\Quality in UML\\WILEY04.pdf','Refactoring a legacy component for reuse in a software product line: a case study','Ronny Kolb; Dirk Muthig; Thomas Patzke; Kazuyuki Yamauchi','Product lines are a promising approach to improve conceptually the productivity of the software development process and thus to reduce both the cost and time of developing and maintaining increasingly complex systems. An important issue in the adoption of the product-line approach is the migration of legacy software components, which have not been designed for reuse, systematically into reusable product-line components. This article describes activities performed to improve systematically the design and implementation of an existing software component in order to reuse it in a software product line. The activities are embedded in the application of Fraunhofer PuLSETM-DSSA - an approach for defining domain-specific software architectures (DSSA) and product-line architectures. The component under investigation is the so-called Image Memory Handler (IMH), which is used in Ricoh\'s current products of office appliances such as copier machines, printers, and multi-functional peripherals. It is responsible for controlling memory usage and compressing and decompressing image data. Improvement of both the component\'s design and implementation are based on a systematic analysis and focused on increasing maintainability and reusability and hence suitability for use in a product line. As a result of the analysis and refactoring activities, the documentation and implementation of the component has been considerably improved as shown by quantitative data collected at the end of the activities. Despite a number of changes to the code, the external behavior of the component has been preserved without significantly affecting the performance. ','refactoring; reuse; legacy component; software product line; code analysis; variability','Journal of Software Maintenance and Evolution: Research and Practice',2006,18,'109-132',NULL,NULL,NULL,'',0,1,2,18,NULL,NULL,NULL,6,NULL),
 (41,'C:\\SLRTool\\Quality in UML\\WILEY05.pdf','Exploiting design patterns to automate validation of class invariants','Brian A. Malloy; James F. Power','In this paper, techniques are presented that exploit two design patterns, the Visitor pattern and the Decorator pattern, to validate invariants about the data attributes in a C++ class automatically. To investigate the pragmatics involved in using the two patterns, a study of an existing, well-tested application, keystone, a parser and front-end for the C++ language, is presented. Results from the study indicate that these two patterns provide flexibility in terms of the frequency and level of granularity of validation of the class invariants, which are expressed in the Object Constraint Language (OCL). The quantitative results measure the impact of these approaches and the additional faults uncovered through validation of the case study. ','class invariants; validation; design patterns; Object Constraint Language','Software Testing, Verification and Reliability',2006,18,'71-95',NULL,NULL,NULL,'',1,0,2,18,NULL,NULL,NULL,6,NULL),
 (42,'C:\\SLRTool\\Quality in UML\\WILEY06.pdf','Assessing the capability of internal metrics as early indicators of maintenance effort through experimentation','Marcela Genero Bocco; Daniel L. Moody; Mario Piattini','The complexity of software artifacts is widely believed to be an important determinant of maintenance effort. This paper conducts an experimental analysis of the impact of complexity on the maintenance of the Unified Modeling Language (UML) class diagrams. This represents an analysis of the effect of an internal quality attribute on an external quality attribute. A range of complexity metrics are proposed based on an ontological analysis of the UML language and previous research. The relative influence of these metrics on maintenance effort is then evaluated using a laboratory experiment. A within-subjects design was used, with subjects required to modify a range of UML class diagrams with different levels of complexity. Only two of the metrics emerged as significant determinants of maintenance effort: number of methods and number of associations. Together these explain around 28% of the variation in maintenance effort. While these findings are encouraging, further research is necessary to explore the ability of these metrics to predict maintenance effort.','complexity; Unified Modeling Language (UML); class diagram; object-oriented (OO) modeling; experimental research; software quality','Journal of Software Maintenance and Evolution: Research and Practice',2005,17,'225-246',NULL,NULL,NULL,'',0,0,3,18,NULL,NULL,NULL,6,NULL),
 (43,'C:\\SLRTool\\Quality in UML\\WILEY07.pdf','Integrating diverse paradigms in evolution and maintenance by an XML-based unified model','Chih-Wei Lu; William C. Chu; Chih-Hung Chang; Don-Lin Yang; Wen-Da Lian','Many disparate software analysis/design methods and tools (called paradigms in this paper) individually offer faster and more efficient software design/evolution, yet they are generally partially incompatible. Therefore, when they are used together, they suffer from a lack of communication and integration. Unanticipated and inadvertent inconsistencies arising from the implicit incompatibilities result in significantly increased costs and errors during software maintenance. To improve both software evolution and maintenance, we propose an XML-based model that effectively unifies and integrates current software paradigms while helping reduce ripple effects and related software maintenance difficulties. ','life cycle; software models; software meta-models; model unification; model integration; ripple effects; XML','Journal of Software Maintenance and Evolution: Research and Practice',2003,13,'111-144',NULL,NULL,NULL,'',0,1,3,18,NULL,NULL,NULL,6,NULL),
 (44,'C:\\SLRTool\\Quality in UML\\WILEY08.pdf','Test adequacy criteria for UML design models','Anneliese Andrews; Robert France; Sudipto Ghosh; Gerald Craig','Systematic design testing, in which executable models of behaviours are tested using inputs that exercise scenarios, can help reveal flaws in designs before they are implemented in code. In this paper a technique for testing executable forms of UML (Unified Modelling Language) models is described and test adequacy criteria based on UML model elements are proposed. The criteria can be used to define test objectives for UML designs. The UML design test criteria are based on the same premise underlying code test criteria: coverage of relevant building blocks of models is highly likely to uncover faults. The test adequacy criteria proposed in this paper are based on building blocks for UML class and interaction diagrams. Class diagram criteria are used to determine the object configurations on which tests are run, while interaction diagram criteria are used to determine the sequences of messages that should be tested. ','design reviews; software testing; test adequacy criteria; UML; class diagram; collaboration diagram; category partitioning','Software Testing, Verification and Reliability',2003,13,'95-127',NULL,NULL,NULL,'',1,0,2,18,NULL,NULL,NULL,6,NULL),
 (45,'C:\\SLRTool\\Quality in UML\\WILEY09.pdf','Relating functional requirements and software architecture: separation and consistency of concerns','R. Heckel; G. Engels','In the early stages of most software processes, functional and non-functional (such as architectural, performance, or security) requirements are expressed separately in different sub-models. Later these requirements have to be integrated into one overall system design. The integration raises consistency issues between different sub-models, which have to be resolved in the process.If requirements evolve over time, this leads to changes to the sub-models concerned. Thus, new consistency issues arise between changed and unchanged sub-models. In this case, a clear separation of concerns between different sub-models is required to keep the effect of changes as local as possible.In this paper, we use a relational approach to couple functional and architectural models while keeping them separated in order to simplify change. The approach uses meta modeling to support the static integration and concepts from the theory of graph transformation to formalize the semantic consistency of the dynamic aspects.','typed graph transformation; meta modeling; model evolution','Journal of Software Maintenance and Evolution: Research and Practice',2002,14,'371-388',NULL,NULL,NULL,'',0,0,5,18,NULL,NULL,NULL,6,NULL),
 (46,'C:\\SLRTool\\Quality in UML\\ACM5.pdf','The Role of Experience and Ability in Comprehension Tasks Supported by UML Stereotypes','Filippo Ricca; Massimiliano Di Penta; Marco Torchiano; Paolo Tonella; Mariano Ceccato ','Proponents of design notations tailored for specific application domains or reference architectures, often available in the form of UML stereotypes, motivate them by improved understandability and modifiability. However, empirical studies that tested such claims report contradictory results, where the most intuitive notations are not always the best performing ones. This indicates the possible existence of relevant influencing factors, other than the design notation itself. In this work we report the results of a family of three experiments performed at different locations and with different subjects, in which we assessed the effectiveness of UML stereotypes for Web design in support to comprehension tasks. Replications with different subjects allowed us to investigate whether subjects\' ability and experience play any role in the comprehension of stereotyped diagrams. We observed different behaviors of users with different degrees of ability and experience, which suggests alternative comprehension strategies of (and tool support for) different categories of users. ','stereotypes; program comprehension; empirical study; developers’ experience',NULL,2007,NULL,'375-384',NULL,NULL,NULL,'',0,1,NULL,17,NULL,29,'International Conference on Software Engineering',3,NULL),
 (47,'C:\\SLRTool\\Quality in UML\\ACM9.pdf','A Comparison of Metrics for UML Class Diagrams','Tong Yi; Fangjun Wu; Chengzhi Gan ','Currently, more and more research results on measuring class diagrams have been developed in literatures. In order to study these metrics systematically and deeply, this paper analyzes and compares some typical metrics for UML class diagrams from different viewpoints, different types of relationships, different types of metric values, complexity, and theoretical and empirical validation. Finally, the authors discuss their advantages and disadvantages as well as the existing problems and the prospects.','UML; class diagram; structure complexity; metric; measure; theoretical validation; empirical validation','ACM SIGSOFT Software Engineering Notes',2004,19,'1 - 6',NULL,NULL,NULL,'',0,0,5,17,NULL,NULL,NULL,6,NULL),
 (48,'C:\\SLRTool\\Quality in UML\\ACM10.pdf','An empirical assessment of using stereotypes to improve reading techniques in software inspections','Miroslaw Staron; Ludwik Kuzniarz; Christian Thurn ','Stereotypes were introduced into the Unified Modeling Language (UML) in order to provide a means of customizing the language for particular needs. The stereotypes can increase the comprehension of UML diagrams and therefor influence reading techniques used for inspections of software artefacts. In this paper we evaluate how the usage of stereotypes in UML designs influences outcomes of three reading techniques used for verification and validation of UML models. The study presented in this paper is done in the context of the UML domain modeling, but the results can be generalized to other kinds of models expressed in UML. The results show that the presence of stereotypes improves the efficiency and effectiveness of the studied methods and shows the magnitude of the improvements. We also investigate which of the reading techniques are the most efficient and effective for analysis of UML designs with stereotypes.','',NULL,2005,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,17,NULL,3,NULL,4,'workshop on Software quality '),
 (49,'C:\\SLRTool\\Quality in UML\\ACM11.pdf','System-On-Chip Validation using UML and CWL','Qiang Zhu; Ryosuke Oishi; Takashi Hasegawa; Tsuneo Nakata ','In this paper, a novel method for high-level specification and validation of SoC designs using UML is proposed. UML is introduced as a formal model of specification for SoC design. The consistency and completeness of the specification is validated based on the formal UML model. The implementation is validated by a systematic derivation of test scenarios and specification based coverage metrics from the UML model. The method has been applied to the design of a new media-processing chip for mobile devices. The application of the method shows that it is not only effective for finding logical errors in the implementation, but also eliminates errors due to inconsistency and incompleteness of the specification. ','Verification Process, UML, Validation and Verification, Specification Modeling',NULL,2004,NULL,NULL,NULL,NULL,NULL,'',0,1,NULL,17,NULL,2,'international conference on Hardware/software codesign and system synthesis ',3,NULL),
 (51,'C:\\SLRTool\\Quality in UML\\ACM13.pdf','Empirical Analysis of Entropy Distance Metric for UML Class Diagrams','Tong Yi; Fangjun Wu ','Many software systems built in recent years have been developed using the UML and, in some cases, they already need adaptive maintenance in order to satisfy market and customer needs. Thus a strong emphasis on analysis metrics for software development is necessary. Analysis metrics play an important role in helping developers understand software and, hence, improve software quality and developer productivity. In this paper, we provide empirical evidence for supporting the role of the structure complexity metrics for UML class diagrams, specifically Zhou\'s metric. Our results, based on data related with bank information system, indicate that the metric is basically consistent with human beings\' intuitions.','UML class diagram; software measure; structure complexity; entropy distance; correlation analysis','ACM SIGSOFT Software Engineering Notes',2004,29,'1 - 6',NULL,NULL,NULL,' ',0,0,5,17,NULL,NULL,NULL,6,NULL),
 (52,'C:\\SLRTool\\Quality in UML\\ACM16.pdf','The Influence of the Level of Abstraction on the Evolvability of Conceptual Models of Information Systems','Jan Verelst ','In today\'s dynamic environments, evolvability of information systems is an increasingly important characteristic. We investigate evolvability at the analysis level, i.e. at the level of the conceptual models that are built of information systems (e.g. UML models). More specifically, we focus on the influence of the level of abstraction of the conceptual model on the evolvability of the model. Abstraction or genericity is a fundamental principle in several research areas such as reuse, patterns, software architectures and application frameworks. The literature contains numerous but vague claims that software based on abstract conceptual models has evolvability advantages. Hypotheses were tested with regard to whether the level of abstraction influences the time needed to apply a change, the correctness of the change and the structure degradation incurred. Two controlled experiments were conducted with 136 subjects. Correctness and structure degradation were rated by human experts. Results indicate that, for some types of change, abstract models are better evolvable than concrete ones. Our results provide insight into how the rather vague claims in literature should be interpreted.','Conceptual modelling; evolvability; maintainability; abstraction','Empirical Software Engineering',2005,10,'17 - 26  ',NULL,NULL,NULL,'',0,0,4,17,NULL,NULL,NULL,6,NULL),
 (53,'C:\\SLRTool\\Quality in UML\\ACM17.pdf','Nice Class Diagrams Admit Good Design?','Holger Eichelberger ','Analysis and design of programs by using tools has emerged to a standard technique in object-oriented software engineering. Many of these tools claim to implement methods according to the UML standard and some of the tools provide automatic layout of the diagrams drawn by the user or generated automatically from source code. In this paper we propose a set of aesthetic criteria for UML class diagrams and discuss the relation between these criteria, HCI and design aspects of object-oriented software.First we describe critics from the viewpoint of HCI to the UML notation and restrict ourself to changes which do not require nonstandard modifications to the UML notation guide, then we list quality relations between class diagrams and object-oriented software models. After that our set of aesthetic criteria, that reflect the highly sophisticated structural and semantic features of UML class diagrams, is explained. Finally, we show that an implementation and measurement of this proposal is realizable using a prototypical graph drawing framework.','UML class diagrams; aesthetics; metrics; HCI; software engineering',NULL,2003,NULL,'159 - ff',NULL,NULL,NULL,'',0,0,NULL,17,NULL,NULL,'ACM symposium on Software visualization ',3,NULL),
 (54,'C:\\SLRTool\\Quality in UML\\ACM19.pdf','Agile Integration Modeling Language (AIML): A conceptual modeling grammar for agile integrative business information systems','Hong Zhang; Rajiv Kishore; Raj Sharman; Ram Ramesh ','The proliferation of newer agile integrative business information systems (IBIS) environments that use the software agent and the multiagent systems paradigms has created the need for a common and well-accepted conceptual modeling grammar that can be used to efficiently, precisely, and unambiguously, model agile IBIS systems at the conceptual level. In this paper, we propose a conceptual modeling grammar termed Agile Integration Modeling Language (AIML) based on established ontological foundation for the multiagent-based integrative business information systems (MIBIS) universe. The AIML grammar provides adequate and precise constructs and semantics for modeling agile integration among participating work systems in terms of quickly building and dismantling dynamic collaboration relationships among them to respond to fast-changing market needs. The AIML grammar is defined as a formal model using Extended BNF and first order logic, and is elaborated using a running example in the paper. The grammar is also evaluated in terms of its syntactic, semantic, and pragmatic qualities and is found to exhibit a high degree of quality on all these three dimensions. In particular, the pragmatic quality of AIML measured in terms of grammar complexity evaluated using complexity metrics indicates that AIML is much easier to learn and use as compared to the Unified Modeling Language (UML) for modeling agile integration of work systems in organizations. ','Conceptual modeling grammar; Systems modeling; Requirements specifications; Role-based modeling; Multiagent systems modeling; Integrative business information systems modeling','Decision Support Systems',2007,44,'266-284',NULL,NULL,NULL,'',1,0,1,17,NULL,NULL,NULL,6,NULL),
 (55,'C:\\SLRTool\\Quality in UML\\ACM20.pdf','An Initial Experimental Assessment of the Dynamic Modelling in UML','Mari Carmen Otero; José Javier Dolado ','The goal of this empirical study is to compare the semantic comprehension of three different notations for representing the dynamic behaviour in unified modelling language (UML): (a) sequence diagrams, (b) collaboration diagrams, and (c) state diagrams. Eighteen students of Informatics analysed the three types of diagrams within three different application domains. We performed a 3 × 3 factorial experimental design with repeated measures. The metrics collected were total time and total score. The main conclusion of this study is that the comprehension of the dynamic modelling in object-oriented designs depends on the diagram type and on the complexity of the document. The software project design written in the UML notation is more comprehensible, when the dynamic behaviour is modelled in a sequence diagram. While if it is implemented using a collaboration diagram, the design turns out to be less comprehensible as the application domain, and consequently, the document is more complex.','Dynamic modelling; unified modelling language; semantic comprehension; 3 x 3 Latin square','Empirical Software Engineering',2002,7,'27-47',NULL,NULL,NULL,'',0,0,1,17,NULL,NULL,NULL,6,NULL),
 (56,'C:\\SLRTool\\Quality in UML\\ACM28.pdf','UML class diagram syntax: an empirical study of comprehension','Helen C. Purchase; Linda Colpoys; Matthew McGill; David Carrington; Carol Britton ','Despite UML being considered a software engineering standard, the UML syntactic notations used in texts, papers, documentation and CASE tools are often different. The decision as to which of the semantically equivalent notational variations to use appears to be according to the personal preference of the author or publisher, rather than based on any consideration of the ease with which the notation can be understood by human readers. This paper reports on an experiment that takes a human comprehension perspective on UML class diagram notational variants. Five notations were considered: for each, two semantically equivalent, yet syntactically different, variations were chosen from published texts. Our experiment required subjects to indicate whether a supplied specification matched each of a set of experimental diagrams. The results reveal that the best performing notation may depend on the task for which it is used, and that our personal, intuitive predictions intuitions (which were based in the complexity of the notation) were partly confirmed. ','UML class diagrams; notation; human performance','Asia-Pacific symposium on Information visualisation',2001,1,'113-120',NULL,NULL,NULL,'',0,0,NULL,17,NULL,NULL,NULL,3,NULL),
 (57,'C:\\SLRTool\\Quality in UML\\ACM30.pdf','Three Dimensional UML Using Force Directed Layout','Tim Dwyer ','There is evidence to suggest that three dimensional representations of connected graphs have a number of advantages in conveying information to users over their two-dimensional counterparts. In this paper we explore the use of a Force Directed Algorithm to layout three dimensional UML Class diagrams representing the architecture of object oriented software systems. We describe a simple evaluation and usability study conducted on the proposed system and present our findings which indicate some unexpected benefits to a user\'s perception the visualised architectural structure.','UML; Force Directed Algorithm; Three Dimensional; Software Model','Asia-Pacific symposium on Information visualisation',2001,9,'77-85',NULL,NULL,NULL,'',0,0,NULL,17,NULL,NULL,NULL,3,NULL),
 (58,'C:\\SLRTool\\Quality in UML\\ACM33.pdf','Testing UML designs','Orest Pilskalns; Anneliese Andrews; Andrew Knight; Sudipto Ghosh; Robert France ','Early detection and correction of faults in the software design phase can reduce total cost and time to market of a software product. In this paper we describe an approach for testing UML design models to uncover inconsistencies. Our approach uses behavioral views such as Sequence Diagrams to simulate state change in an aggregate model. The aggregate model is the artifact of merging information from behavioral and structural UML views. OCL pre-conditions, post-conditions and invariants are used as a test oracle. ','UML design models; Sequence diagrams; UML views; OCL pre-condition and post-condition; Class diagrams','Information and Software Technology',2007,49,'892-912',NULL,NULL,NULL,'',0,0,8,17,NULL,NULL,NULL,6,NULL),
 (59,'C:\\SLRTool\\Quality in UML\\SD02.pdf','USE: A UML-based specification environment for validating UML and OCL','Martin Gogolla; Fabian Büttner; Mark Richters','The Unified Modeling Language (UML) is accepted today as an important standard for developing software. UML tools however provide little support for validating and checking models in early development phases. There is also no substantial support for the Object Constraint Language (OCL). We present an approach for the validation of UML models and OCL constraints based on animation and certification. The USE tool (UML-based Specification Environment) supports analysts, designers and developers in executing UML models and checking OCL constraints and thus enables them to employ model-driven techniques for software production.','UML; OCL; Model; Constraint; Invariant; Pre- and post-conditions; Model validation; Model certification; Model execution','Science of Computer Programming - Special issue on Experimental Software and Toolkits',2007,69,'27-34',NULL,NULL,NULL,'',0,0,1,21,NULL,NULL,NULL,6,NULL),
 (60,'C:\\SLRTool\\Quality in UML\\SD03.pdf','Generating Scenarios by Multi-Object Checking','Maik Kollmann; Yuen Man Hon','These days, many systems are developed applying various UML notations to represent the structure and behavior of (technical) systems. In addition, for safety critical systems like Railway Interlocking Systems (RIS) the fulfillment of safety requirements is demanded. UML-based Railway Interlocking (UML-based RI) is proposed as a methodology in designing and developing RIS. It consists of infrastructure objects and UML is used to model the system behavior. This design is validated and demonstrated by using simulation with Rhapsody. Automated verification techniques like model checking have become a standard for proving the correctness of state-based systems. Unfortunately, one major problem of model checking is the state space explosion if too many objects have to be taken into account. Multi-object checking circumvents the state space explosion by checking one object at a time. We present an approach to enhance multi-object checking by generating counterexamples in a sequence diagram fashion providing scenarios for model-based testing.','Scenario Generation; Counterexample Generation; State Modeling; Multi-Object Checking, UML-based Railway Interlocking System','Electronic Notes in Theoretical Computer Science',2007,190,'61-72',NULL,NULL,NULL,'',0,0,2,21,NULL,NULL,NULL,6,NULL),
 (61,'C:\\SLRTool\\Quality in UML\\SD04.pdf','Ownership as a conceptual modeling construct','Michael Halper; Li-min Liu; James Geller; Yehoshua Perl','Ownership is a relationship that pervades many aspects of our lives, from the personal to the economic, and is particularly important in the realm of the emerging electronic economy. As it is understood on an intuitive level, ownership exhibits a great deal of complexity and carries a rich semantics with respect both to the owner and the possession. A formal model of an ownership relationship that inherently captures varied ownership semantics is presented. This ownership relationship expands the repertoire of available conceptual data modeling primitives. It is built up from a set of characteristic dimensions, namely, exclusiveness, dependency, documentation, transferability, and inheritance, each of which focuses on a specific aspect of ownership semantics. The data modeler has the ability to make a variety of choices along these five dimensions, and thus has access to a wide range of available ownership features in a declarative fashion. These choices ultimately impose various constraints (specified in OCL) on the states of data objects and their respective ownership activities, including transactions such as acquiring and relinquishing ownership. To complement the formal aspects of the ownership model and enhance its usability, we present a graphical ownership notation that augments the Unified Modeling Language (UML) class diagram formalism. An implementation of the ownership relationship in a commercial object-oriented database system is discussed.','Ownership relationship; Semantic relationship; Ownership semantics; Conceptual modeling; Object-oriented modeling; Object-oriented database system; Electronic commerce',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'',0,1,NULL,21,NULL,NULL,NULL,6,NULL),
 (62,'C:\\SLRTool\\Quality in UML\\SD05.pdf','Supporting task-oriented modeling using interactive UML views','Christian F.J. Lange; Martijn A.M. Wijns; Michel R.V. Chaudron','The UML is a collection of 13 diagram notations to describe different views of a software system. The existing diagram types display model elements and their relations. Software engineering is becoming more and more model-centric, such that software engineers start using UML models for more tasks than just describing the system. Tasks such as analysis or prediction of system properties require additional information such as metrics of the UML model or from external sources, e.g. a version control system. In this paper we identify tasks of model-centric software engineering and information that is required to fulfill these tasks. We propose views to visualize the information to support fulfilling the tasks. This paper reports on a large-scale controlled experiment to validate the usefulness of the proposed views that are implemented in our MetricView Evolution tool. The results of the experiment with 100 participants are statistically significant and show that the correctness of comprehension is improved by 4.5% and that the time needed is reduced by 20%.','UML; Interactive views; Quality; Task-orientation; Metrics; Comprehension; Empirical validation','Journal of Visual Languages and Computing',2007,18,'399-419',NULL,NULL,NULL,'',0,1,4,21,NULL,NULL,NULL,6,NULL),
 (63,'C:\\SLRTool\\Quality in UML\\SD07.pdf','A rationale-based architecture model for design traceability and reasoning','Antony Tang; Yan Jin; Jun Han','Large systems often have a long life-span and comprise many intricately related elements. The verification and maintenance of these systems require a good understanding of their architecture design. Design rationale can support such understanding but it is often undocumented or unstructured. The absence of design rationale makes it much more difficult to detect inconsistencies, omissions and conflicts in an architecture design. We address these issues by introducing a rationale-based architecture model that incorporates design rationale, design objects and their relationships. This model provides reasoning support to explain why design objects exist and what assumptions and constraints they depend on. Based on this model, we apply traceability techniques for change impact analysis and root-cause analysis, thereby allowing software architects to better understand and reason about an architecture design. In order to align closely with industry practices, we choose to represent the rationale-based architecture model in UML. We have implemented a tool-set to support the capture and the automated tracing of the model. As a case study, we apply this approach to an real-world electronic payment system.','Design rationale; Architecture design; Traceability',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'',0,1,NULL,21,NULL,NULL,NULL,6,NULL),
 (64,'C:\\SLRTool\\Quality in UML\\SD09.pdf','Validating the enforcement of access control policies and separation of duty principle in requirement engineering','Khaled Alghathbar','Validating the compliance of software requirements with the access control policies during the early development life cycle improves the security of the software. It prevents authorizing unauthorized subject during the specification of requirements and analysis before proceeding to other phases where the cost of fixing defects is augmented. This paper provides a logical-based framework that analyzes the authorization requirements specified in the Unified Modeling Language (UML). It ensures that the access requirements are consistent, complete and conflict-free. The framework proposed in this paper is an extension to AuthUML framework. We refine AuthUML and extend it by expanding its analysis to validate the enforcement of the Separation of Duty (SoD) during the requirement engineering. We enhance and extend AuthUML with the necessary phase, predicates and rules. The paper shows the various types of SoD and how each type can be validated. The extension shows the flexibility and scalability of AuthUML to validate new policies. Also, the extension makes AuthUML spans to different phases of the software development process that widen the application of AuthUML.','Access control policies; Security engineering; Use cases; Semi-formal methods; Separation of duty','Information and Software Technology',2007,49,'142-157',NULL,NULL,NULL,'',0,0,2,21,NULL,NULL,NULL,6,NULL),
 (65,'C:\\SLRTool\\Quality in UML\\SD14.pdf','WAVer: A Model Checking-based Tool to Verify Web Application Design','D. Castelluccia; M. Mongiello; M. Ruta; R. Totaro','Web Applications are becoming more and more widespread and efficient, then an increase of their reliability is now strongly required. Hence methods to support design and automatically perform validation of a Web Application (WA) could be helpful. In this paper we present WAVer, a prototype tool for performing the verification of a WA design by means of Symbolic Model Checking techniques. The tool first performs the modeling of the WA and furthermore verify it by means of a model checker. Specifically, the mathematical model of the WA is represented by a Finite State Machine (FSM). Then, by using the CTL formal language, we formalize basic criteria to establish correctness of the application. The prototype system we have implemented embeds a component which automatically imports WA design from a UML tool; CTL specifications are added and translated as source code for NuSMV model checker. Finally, the checker performs verification: if there is a violation of specifications, NuSMV allows to locate errors in WA design and appropriate adjustments are carried out.','web application; verification; model checking','Electronic Notes in Theoretical Computer Science',2006,157,'61-76',NULL,NULL,NULL,'',0,0,1,21,NULL,NULL,NULL,6,NULL),
 (66,'C:\\SLRTool\\Quality in UML\\SCOPUS02.pdf','Towards quantitative evaluation of UML based software architecture','Li J.; Guo Z.; Zhao Y; Zhang Z.; Pang Ruijuan','The architecture of a software system is a critical artifact in the software lifecycle and should be evaluated as early as possible. Recent efforts to software architecture evaluation are concentrated on scenario-based methods which are qualitative, subjective and need not any special architecture description languages. This paper investigates an approach to metrics based quantitative evaluation of UML software architecture. UML is a visual modeling language with well-formed hierarchical syntax and semantics, and is uniformly applied in various development stages. With supplementation UML has been adapted to describing software architecture. By utilization of these features three types of metrics for UML diagrams are proposed They measure the amount of information, visual effect and connectivity degree in different UML diagrams. The application of these metrics in quantitative evaluating qualities at the architecture-level such as system scale, complexity and structural characteristics is discussed. ','  ',NULL,NULL,NULL,'663-669',NULL,NULL,NULL,'',0,0,NULL,19,'',8,'International Conference on Software Engineering, Artificial Intelligence, Networking, and Parallel/Distributed Computing',3,NULL),
 (67,'C:\\SLRTool\\Quality in UML\\SCOPUS06.pdf','Formal Semantics and Reasoning about UML Class Diagram','Szlenk M. ','The main way of coping with the complexity of software systems is to construct and use models expressed in UML Unfortunately, the semantics (meaning) of models written in UML is not precisely defined. It may result in the incorrect interpretation of a model and make it hard to strictly verify a model and its transformation. In this paper we formally (mathematically) define UML class diagram and its semantics. The problem of consistency of the diagram is then introduced and some examples of inconsistencies are forwarded.','',NULL,NULL,NULL,'51-59',NULL,NULL,NULL,'',0,0,NULL,19,'',5,'Proceedings of International Conference on Dependability of Computer Systems',3,NULL),
 (68,'C:\\SLRTool\\Quality in UML\\SCOPUS15.pdf','Performance measures for supporting project manager decisions','Antonia Bertolino; Eda Marchetti; Raffaela Mirandola','Software measurement is a crucial technology along the software development process, and notably for project management. Decision-making in project management requires in fact, accurate estimations and the support of metrics to monitor and control the varying factors affecting the development process. Managers must make reliable schedule predictions and optimize personnel utilization. They therefore must be able to dynamically evaluate whether the resources assigned to a job are sufficient and whether the organization structure is adequate to meet the scheduled deadlines. To support managers in these tasks, we propose a method called Propean (for PROject PErformance ANalysis) based on the combination of classical performance engineering techniques and the Unified Modelling Language (UML). The combined application of these disciplines guarantees on one hand, a validated approach for modelling and estimating the \'Quality of Service\' parameters when they come to the development process. Performance engineering techniques are in fact based on rigorous mathematical formalisms such as queueing networks, stochastic Petri nets and Markov models. On the other hand, the adoption of UML provides managers with an easy-to-use front-end representation of the process closer to the design notations they routinely employ. To illustrate Propean application, in this article, we model the case of a manager who must decide a release date for a product undergoing the testing phase. ','product release; project management; real-time UML; software performance engineering','SOFTWARE PROCESS IMPROVEMENT AND PRACTICE',2007,12,'141-164',NULL,NULL,NULL,'',0,1,2,19,NULL,NULL,NULL,6,NULL),
 (69,'C:\\SLRTool\\Quality in UML\\SCOPUS22.pdf','A unified approach for verification and validation of systems and software engineering models','Alawneh L.;  Debbabi, M.; Hassaïne F.; Jarraya Y.','We present in this paper a unified paradigm for the verification and validation of software and systems engineering design models expressed in UML 2.0 or SysML. This paradigm relies on an established synergy between three salient approaches, which are model-checking, program analysis, and software engineering techniques. To illustrate the accomplishment of our results, we have designed and implemented an integrated and automated computer-aided assessment tool. We provide three case studies for sequence, state machine, and class and package diagrams to demonstrate the benefits of our methodology. ','',NULL,NULL,NULL,'409-418',NULL,NULL,NULL,'',0,0,NULL,19,'',28,'Proceedings of the International Symposium and Workshop on Engineering of Computer Based Systems.',3,NULL),
 (70,'C:\\SLRTool\\Quality in UML\\SCOPUS44.pdf','Validating timed UML models by simulation and verification','Ober I.; Graf S.; Ober I.','This paper presents a technique and a tool for model-checking operational (design level) UML models based on a mapping to a model of communicating extended timed automata. The target language of the mapping is the IF format, for which existing model-checking and simulation tools can be used. Our approach takes into consideration most of the structural and behavioural features of UML, including object-oriented aspects. It handles the combination of operations, state machines, inheritance and polymorphism, with a particular semantic profile for communication and concurrency. We adopt a UML profile that includes extensions for expressing timing. The breadth of concepts covered by our mapping is an important point, as many previous approaches for applying formal validation to UML put much stronger limitations on the considered models. For expressing properties about models, a formalism called UML observers is defined in this paper. Observers reuse existing concepts like classes and state machines, and they allow expressing a significant class of linear temporal properties. The approach is implemented in a tool that imports UML models from an XMI repository, thus supporting several editors like Rational Rose, Rhapsody or Argo. The generated IF models may be simulated and verified via an interface ',NULL,'International Journal on Software Tools for Technology Transfer ',2006,8,'128-145',NULL,NULL,NULL,'',0,0,2,19,NULL,NULL,NULL,6,NULL),
 (71,'C:\\SLRTool\\Quality in UML\\SCOPUS48.pdf','In practice: UML software architecture and design description','Lange C. F. J.; Chaudron, M. R. V.; Muskens J.','UML has been around since 1997. To determine how it\'s being used in current software architecting and design, the authors surveyed practitioners and analyzed case studies of industry projects. Their results show that UML is used rather loosely and  that UML models are often incomplete. This leads to miscommunication and other implementation and maintenance problems. The authors conclude with recommendations and techniques for controlling UML model quality. This article is part of a focus section on software architecture. ',NULL,'IEEE Software',2006,23,'40-46',NULL,NULL,NULL,'',0,0,2,19,NULL,NULL,NULL,6,NULL);
INSERT INTO `documento` (`id`,`ruta`,`titulo`,`autor`,`resumen`,`keywords`,`journal`,`year`,`volumen`,`pages`,`publisher`,`chapter`,`booktitle`,`comentarios`,`excluidoPrimera`,`excluidoSegunda`,`numero`,`fuente`,`lugar`,`edicion`,`conferencia`,`tipo`,`workshop`) VALUES 
 (72,'C:\\SLRTool\\Quality in UML\\SCOPUS66.pdf','Retrieval by construction: A traceability technique to support verification and validation of UML formalizations.','Deng M.; Stirewalt R. E. K; Cheng B.H.C.','Recently, there has been growing interest in formalizing UML, thereby enabling rigorous analysis of its many graphical diagrams. Two obstacles currently limit the adoption and use of UML formallzatlons in practice. First is the need to verify the consistency of artifacts under formalization. Second is the need to validate formalization approaches against domain-specific requirements. Techniques from the emerging field of requirements traceability hold promise for addressing these obstacles. This paper contributes a technique called retrieval by construction (RBC), which establishes traceability links between a UML model and a target model intended to denote its semantics under formalization. RBC provides an approach for structuring and representing the complex one-to-many links that are common between UML and target models under formalization. RBC also uses the notion of value identity in a novel way that enables the specification of the linkretrieval criteria using generative procedures. These procedures are a natural means for specifying UML formalizations. We have validated the RBC technique in a tool framework called UBanyan, written in C++. We applied the tool to three case studies, one of which was obtained from the industry. We have also assessed our results using the two well-known traceability metrics: precision and recall. Preliminary investigations suggest that RBC can be a useful traceability technique for validating and verifying UML formalizations. ','Traceability; U1.1L formalization; retrieval by construction; value identity; generative procedures; precision; recall',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,19,NULL,NULL,NULL,6,NULL),
 (73,'C:\\SLRTool\\Quality in UML\\SRINGER6.pdf','Consistent Adaptation and Evolution of Class Diagrams during Refinement','Alexander Egyed','Software models are key in separating and solving independent development\r\nconcerns. However, there is still a gap on how to transition design\r\ninformation among these separate, but related models during development and\r\nmaintenance. This paper addresses the problem on how to maintain the consistency\r\nof UML class diagrams during various levels of refinement. We present a\r\nnew approach to automated consistency checking called ViewIntegra. Our approach\r\nseparates consistency checking into transformation and comparison. It\r\nuses transformation to translate model elements to simplify their subsequent\r\ncomparison. Transformation-based consistency checking, in the manner we use\r\nit, is new since we use transformation to bridge the gap between software models.\r\nNo intermediate models or model checkers are required; developers need\r\nonly be familiar with the models they design with and none other. The separation\r\nof transformation and comparison makes our approach to consistency\r\nchecking more transparent. It also makes our approach useful for both propagating\r\ndesign changes among models and validating consistency. This gives developers\r\nadded flexibility in deciding when to re-generate a model from scratch\r\nor when to resolve its inconsistencies. Although this paper emphasizes the adaptation\r\nand evaluation of class diagrams, we found our technique to be equally\r\nuseful on other models. Our approach is tool supported.',NULL,NULL,2004,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,20,NULL,NULL,'FASE',3,NULL),
 (74,'C:\\SLRTool\\Quality in UML\\SRINGER7.pdf','Deductive Verification of UML Models in TLPVS ','Tamarah Arons; Jozef Hooman; Hillel Kugler; Amir Pnueli; Mark van der Zwaag','In recent years, UML has been applied to the development\r\nof reactive safety-critical systems, in which the quality of the developed\r\nsoftware is a key factor. In this paper we present an approach for the\r\ndeductive verification of such systems using the PVS interactive theorem\r\nprover. Using a PVS specification of a UML kernel language semantics,\r\nwe generate a formal representation of the UML model. This representation\r\nis then verified using tlpvs, our PVS-based implementation of\r\nlinear temporal logic and some of its proof rules. We apply our method\r\nby verifying two examples, demonstrating the feasibility of our approach\r\non models with unbounded event queues, object creation, and variables\r\nof unbounded domain. We define a notion of fairness for UML systems,\r\nallowing us to verify both safety and liveness properties.','Formal Verification; Deductive Verification; PVS; UML; State\r\nMachines; Semantics; Temporal Logic',NULL,2004,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,20,NULL,NULL,'UML',3,NULL),
 (75,'C:\\SLRTool\\Quality in UML\\SRINGER15.pdf','Formal Proof from UML Models','Nuno Amálio; Susan Stepney; Fiona Polack','We present a practical approach to a formal analysis of UMLbased\r\nmodels. This is achieved by an underlying formal representation in\r\nZ, which allows us to pose and discharge conjectures to analyse models.\r\nWe show how our approach allows us to consistency-check UML models,\r\nand model analysis by simply drawing snapshot diagrams.','UML; Z; model analysis; formal proof; consistency checking',NULL,2004,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,20,NULL,NULL,'ICFEM',3,NULL),
 (76,'C:\\SLRTool\\Quality in UML\\SRINGER27.pdf','An Attempt at Analysing the Consistency Problems in the UML from a Classical Algebraic Viewpoint','E. Astesiano; G. Reggio','In this paper, after introducing the problem and a brief survey\r\nof the current approaches, we look at the consistency problems in\r\nthe UML in terms of the well-known machinery of classical algebraic\r\nspecifications. Thus, first we review how the various kinds of consistency\r\nproblems were formulated in that setting. Then, and this is the first contribution\r\nof our note, we try to reduce, as much as possible, the UML\r\nproblems to that frame. That analysis, we believe, is rather clarifying in\r\nitself and allows us to better understand what is new and what instead\r\ncould be treated in terms of that machinery. We conclude with some\r\ndirections for handling those problems, basically with constrained modelling\r\nmethods that reduce and help precisely individuate the sources of\r\npossible inconsistencies.','',NULL,NULL,NULL,'',NULL,NULL,NULL,'',0,0,NULL,20,'',22,'WADT',3,NULL),
 (77,'C:\\SLRTool\\Quality in UML\\SRINGER29.pdf','OCL-Based Automated Validation Method for UML Specifications','L. Ol\'khovich; D. V. Koznov','The paper is devoted to the validation of visual software models. The aim of the validation is to verify\r\nwhether the models match the visual project language, which is a dialect of a standard visual modeling language\r\n(UML, SDL, etc.) created with regard to specific features of the particular project on software development.\r\nIn the paper, an architecture of a validator designed for both interactive and batch modes is suggested.\r\nAn approach to specifying visual project languages by means of OCL constraints imposed on the UML metamodel\r\nwith the subsequent automated generation of validators in accordance with the architecture described is\r\nsuggested. Results of approbation of the validator and the validator generator in the framework of an industry\r\nproject are presented.','',NULL,NULL,NULL,NULL,NULL,NULL,NULL,'',0,0,NULL,20,NULL,NULL,NULL,6,NULL);
/*!40000 ALTER TABLE `documento` ENABLE KEYS */;


--
-- Definition of table `documentorevision`
--

DROP TABLE IF EXISTS `documentorevision`;
CREATE TABLE `documentorevision` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `idDocumento` int(10) unsigned NOT NULL COMMENT 'Documento',
  `idRevision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  KEY `FK_documentoRevision_1` (`idDocumento`),
  KEY `FK_documentoRevision_2` (`idRevision`),
  CONSTRAINT `FK_documentoRevision_1` FOREIGN KEY (`idDocumento`) REFERENCES `documento` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `FK_documentoRevision_2` FOREIGN KEY (`idRevision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=63 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `documentorevision`
--

/*!40000 ALTER TABLE `documentorevision` DISABLE KEYS */;
INSERT INTO `documentorevision` (`id`,`idDocumento`,`idRevision`) VALUES 
 (3,21,1),
 (4,22,1),
 (5,23,1),
 (6,24,1),
 (7,25,1),
 (8,26,1),
 (9,27,1),
 (10,28,1),
 (11,29,1),
 (12,30,1),
 (13,31,1),
 (14,32,1),
 (15,33,1),
 (16,34,1),
 (17,35,1),
 (18,36,1),
 (19,37,1),
 (20,38,1),
 (21,39,1),
 (22,40,1),
 (23,41,1),
 (24,42,1),
 (25,43,1),
 (26,44,1),
 (27,45,1),
 (28,46,1),
 (29,47,1),
 (30,48,1),
 (31,49,1),
 (32,51,1),
 (33,52,1),
 (34,53,1),
 (35,54,1),
 (36,55,1),
 (37,56,1),
 (38,57,1),
 (39,58,1),
 (40,59,1),
 (41,60,1),
 (42,61,1),
 (43,62,1),
 (44,63,1),
 (45,64,1),
 (46,65,1),
 (47,66,1),
 (48,67,1),
 (49,68,1),
 (50,69,1),
 (51,70,1),
 (52,71,1),
 (53,72,1),
 (54,73,1),
 (55,74,1),
 (56,75,1),
 (57,76,1),
 (58,77,1);
/*!40000 ALTER TABLE `documentorevision` ENABLE KEYS */;


--
-- Definition of table `fuente`
--

DROP TABLE IF EXISTS `fuente`;
CREATE TABLE `fuente` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `nombre` varchar(100) NOT NULL COMMENT 'Nombre de la fuente',
  `revision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  `repetidos` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'Numero de documentos repetidos respecto a otras fuentes',
  PRIMARY KEY (`id`),
  UNIQUE KEY `nombre` (`nombre`,`revision`),
  KEY `FK_fuente_1` (`revision`),
  CONSTRAINT `FK_fuente_1` FOREIGN KEY (`revision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `fuente`
--

/*!40000 ALTER TABLE `fuente` DISABLE KEYS */;
INSERT INTO `fuente` (`id`,`nombre`,`revision`,`repetidos`) VALUES 
 (15,'Grey literature',1,1),
 (16,'IEEE',1,0),
 (17,'ACM',1,1),
 (18,'Wiley Interscience',1,0),
 (19,'Scopus',1,0),
 (20,'Springerlink',1,0),
 (21,'Science Direct',1,0);
/*!40000 ALTER TABLE `fuente` ENABLE KEYS */;


--
-- Definition of table `participante`
--

DROP TABLE IF EXISTS `participante`;
CREATE TABLE `participante` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `nombre` varchar(45) NOT NULL COMMENT 'Nombre del participante',
  `revision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  `tipo` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'Tipo de participante (1=busqueda;2=seleccion;3=ambas)',
  PRIMARY KEY (`id`),
  UNIQUE KEY `nombre` (`nombre`,`revision`) USING BTREE,
  KEY `FK_participante_1` (`revision`),
  CONSTRAINT `FK_participante_1` FOREIGN KEY (`revision`) REFERENCES `revision` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=latin1 COMMENT='Personas que participan en la realizacion de la revision';

--
-- Dumping data for table `participante`
--

/*!40000 ALTER TABLE `participante` DISABLE KEYS */;
INSERT INTO `participante` (`id`,`nombre`,`revision`,`tipo`) VALUES 
 (1,'Ana Fernandez',1,3),
 (2,'Marcela Genero',1,2),
 (5,'Jose Manuel Gomez',1,1);
/*!40000 ALTER TABLE `participante` ENABLE KEYS */;


--
-- Definition of table `preguntas`
--

DROP TABLE IF EXISTS `preguntas`;
CREATE TABLE `preguntas` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `pregunta` varchar(200) NOT NULL COMMENT 'Descripcion de la pregunta',
  `respuesta` varchar(500) NOT NULL COMMENT 'Respuesta a la pregunta',
  `idRevision` int(10) unsigned NOT NULL COMMENT 'Revision a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `pregunta` (`pregunta`,`idRevision`),
  KEY `FK_Preguntas_1` (`idRevision`),
  CONSTRAINT `FK_Preguntas_1` FOREIGN KEY (`idRevision`) REFERENCES `revision` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=latin1 COMMENT='Preguntas a responder por la SLR';

--
-- Dumping data for table `preguntas`
--

/*!40000 ALTER TABLE `preguntas` DISABLE KEYS */;
INSERT INTO `preguntas` (`id`,`pregunta`,`respuesta`,`idRevision`) VALUES 
 (1,'Which type of UML diagrams is the focus of the research on UML model quality?','class and sequence diagrams',1),
 (2,'Which research methods are used in research on UML model quality?','',1),
 (3,'What is the nature of the research results on UML model quality? ','',1),
 (4,'Which type of UML model quality has been investigated by researchers?','',1),
 (5,'Which research goals are aimed at in research on UML model quality?','',1),
 (6,'hyijç','tgyk',1);
/*!40000 ALTER TABLE `preguntas` ENABLE KEYS */;


--
-- Definition of table `revision`
--

DROP TABLE IF EXISTS `revision`;
CREATE TABLE `revision` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `titulo` varchar(150) NOT NULL COMMENT 'Titulo o nombre de la revision',
  `antecedentes` varchar(1500) NOT NULL COMMENT 'Antecedentes de la revision',
  `fechaInicio` datetime DEFAULT NULL COMMENT 'Fecha de inicio de la revision',
  `fechaFin` datetime DEFAULT NULL COMMENT 'Fecha de finalizacion de la revision',
  `justificacion` varchar(1500) NOT NULL COMMENT 'Justificacion para llevar a cabo la revision',
  `estrategiasSeleccion` varchar(2000) NOT NULL COMMENT 'Estrategia de seleccion de la revision',
  `estrategiaExtraccion` varchar(2000) NOT NULL COMMENT 'Estrategia de extraccion de la revision',
  `estrategiaSintensis` varchar(2000) NOT NULL COMMENT 'Estrategia de sintesis de la revision',
  `estrategiaDivulgacion` varchar(2000) NOT NULL COMMENT 'Estrategia de divulgacion de la revision',
  `resolucionConflictos` varchar(2000) NOT NULL COMMENT 'Estrategia de resolucion de conflictos de la revision',
  `planificacion` varchar(2000) NOT NULL COMMENT 'Planificacion de la revision',
  PRIMARY KEY (`id`),
  UNIQUE KEY `titulo` (`titulo`),
  UNIQUE KEY `titulo_2` (`titulo`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `revision`
--

/*!40000 ALTER TABLE `revision` DISABLE KEYS */;
INSERT INTO `revision` (`id`,`titulo`,`antecedentes`,`fechaInicio`,`fechaFin`,`justificacion`,`estrategiasSeleccion`,`estrategiaExtraccion`,`estrategiaSintensis`,`estrategiaDivulgacion`,`resolucionConflictos`,`planificacion`) VALUES 
 (1,'Quality in UML','1. Genero, M., Piattini, M., & Calero, C. (2005). A Survey of Metrics for UML Class Diagrams. Journal of Object Technology, 4(9), 59-92.\n2. Moody, D. L. (2005). Theoretical and practical issues in evaluating the quality of conceptual models: current state and future directions. Data and Knowledge Engineering, 55(3), 243-276.\n3. Pretorius, R., & Budgen, D. (2008). A mapping study on empirical evidence related to the models and forms used in the uml. In Proceedings of the Second ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (pp. 342-344). Kaiserslautern, Germany: ACM.','2009-06-30 00:00:00','2009-10-01 00:00:00','Research on what is related to the quality of UML to find new areas of study','','','','','When there is a conflict in the selection of a document, there will be a\r\nmeeting in which each participant shall give the reasons for selection or rejection. \r\nIf you have well not reached any consensus is left to the participant with more\r\nexperience.','week 1: do the search\nweek 2: import documents\n...'),
 (10,'XML language','',NULL,NULL,'','','','','','','');
/*!40000 ALTER TABLE `revision` ENABLE KEYS */;


--
-- Definition of table `tipodocumento`
--

DROP TABLE IF EXISTS `tipodocumento`;
CREATE TABLE `tipodocumento` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `tipo` varchar(45) NOT NULL COMMENT 'Tipo de documento',
  `tipoEn` varchar(45) NOT NULL COMMENT 'Tipo de documento en ingles',
  PRIMARY KEY (`id`),
  UNIQUE KEY `tipo` (`tipo`),
  UNIQUE KEY `tipo_2` (`tipo`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `tipodocumento`
--

/*!40000 ALTER TABLE `tipodocumento` DISABLE KEYS */;
INSERT INTO `tipodocumento` (`id`,`tipo`,`tipoEn`) VALUES 
 (1,'Libro','Book'),
 (2,'Capítulo','Chapter'),
 (3,'Conferencia','Proceedings'),
 (4,'Workshop','Workshop'),
 (5,'Informe','Report'),
 (6,'Revista','Journal'),
 (7,'Genérico','Generic');
/*!40000 ALTER TABLE `tipodocumento` ENABLE KEYS */;


--
-- Definition of table `valor`
--

DROP TABLE IF EXISTS `valor`;
CREATE TABLE `valor` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identificador',
  `valor` varchar(45) NOT NULL COMMENT 'Nombre del valor',
  `categoria` int(10) unsigned NOT NULL COMMENT 'Categoria (o subcategoria) a la que pertenece',
  PRIMARY KEY (`id`),
  UNIQUE KEY `valor` (`valor`,`categoria`),
  KEY `FK_Valor_1` (`categoria`),
  CONSTRAINT `FK_Valor_1` FOREIGN KEY (`categoria`) REFERENCES `categoria` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=28 DEFAULT CHARSET=latin1;

--
-- Dumping data for table `valor`
--

/*!40000 ALTER TABLE `valor` DISABLE KEYS */;
INSERT INTO `valor` (`id`,`valor`,`categoria`) VALUES 
 (7,'activity',1),
 (27,'all',1),
 (19,'analyzability',5),
 (1,'classes',1),
 (11,'collaboration',1),
 (16,'completness',4),
 (25,'complexity',5),
 (2,'component',1),
 (4,'composite structure',1),
 (15,'consistency',4),
 (14,'correctness',3),
 (17,'correctness',4),
 (26,'dependency',5),
 (5,'deployment',1),
 (23,'executability',5),
 (22,'functionality',5),
 (13,'interaction overview',1),
 (18,'mantainability',5),
 (3,'object',1),
 (6,'package',1),
 (24,'reusability',5),
 (10,'sequence',1),
 (9,'statechart',1),
 (21,'testability',5),
 (12,'timing',1),
 (20,'understandability',5),
 (8,'use case',1);
/*!40000 ALTER TABLE `valor` ENABLE KEYS */;

create user usuarioslrtool identified by 'slrtool2293';
grant all on slrtool.* to usuarioslrtool identified by 'slrtool2293';


/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
